#include "SyntaxTree.h"

namespace SimplePascal
{
	void PrimitiveType::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void PointerType::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void Parameter::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void FunctionType::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void LiteralExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void VariableExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void Argument::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void InvokeExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void CastExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void SizeOfExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void NotExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void AddressExpressoin::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void PointerValueExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void RelationExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void AndExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void OrExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void AddExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void SubExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void MulExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void DivExpression::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void ExpressionStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void AssignStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void IfStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void WhileStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void RepeatStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void ControlStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void ResultStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void BlockStatement::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void Variable::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void Var::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void Function::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}

	void Program::Accept(SyntaxTreeVisitor* visitor)
	{
		visitor->Visit(this);
	}


	/*

	void Visit(PrimitiveType* type)
	{
	}

	void Visit(PointerType* type)
	{
	}

	void Visit(Parameter* parameter)
	{
	}

	void Visit(FunctionType* type)
	{
	}

	void Visit(PrimitiveExpression* expression)
	{
	}

	void Visit(LiteralExpression* expression)
	{
	}

	void Visit(VariableExpression* expression)
	{
	}

	void Visit(Argument* argument)
	{
	}

	void Visit(InvokeExpression* expression)
	{
	}

	void Visit(CastExpression* expression)
	{
	}

	void Visit(SizeOfExpression* expression)
	{
	}

	void Visit(NotExpression* expression)
	{
	}

	void Visit(AddressExpressoin* expression)
	{
	}

	void Visit(PointerValueExpression* expression)
	{
	}

	void Visit(RelationExpression* expression)
	{
	}

	void Visit(AndExpression* expression)
	{
	}

	void Visit(OrExpression* expression)
	{
	}

	void Visit(AddExpression* expression)
	{
	}

	void Visit(SubExpression* expression)
	{
	}

	void Visit(MulExpression* expression)
	{
	}

	void Visit(DivExpression* expression)
	{
	}

	void Visit(ExpressionStatement* statement)
	{
	}

	void Visit(AssignStatement* statement)
	{
	}

	void Visit(IfStatement* statement)
	{
	}

	void Visit(WhileStatement* statement)
	{
	}

	void Visit(RepeatStatement* statement)
	{
	}

	void Visit(ControlStatement* statement)
	{
	}

	void Visit(ResultStatement* statement)
	{
	}

	void Visit(BlockStatement* statement)
	{
	}

	void Visit(Variable* variable)
	{
	}

	void Visit(Var* var)
	{
	}

	void Visit(Function* function)
	{
	}

	void Visit(Program* program)
	{
	}

	*/
}